// pages/text/text.ts

Page({
  /**
   * 页面的初始数据
   */
  data: {
    questions: [] as Question[], // 题目列表
    currentIndex: 0, // 当前题目索引
    currentQuestion: {} as Question, // 当前显示的题目
    selectedOption: '', // 用户选择的选项
    score: 0, // 当前分数
    totalQuestions: 0, // 总题目数
    showResult: false, // 是否显示答题结果
    isCorrect: false, // 当前题目是否答对了
    answerHistory: [] as Array<{questionId: number, userAnswer: string, correctAnswer: string, isCorrect: boolean}>, // 答题历史
    
    // 答题模式配置
    quickMode: true, // 快速模式：选择答案后自动进入下一题
    autoNextDelay: 1500, // 自动进入下一题的延迟时间（毫秒）
    showDetailedFeedback: true, // 是否显示详细的答题反馈
    
    // 时间记录
    examStartTime: 0, // 考试开始时间戳
    currentQuestionStartTime: 0, // 当前题目开始时间戳
    questionTimeRecords: [] as Array<{questionId: number, timeSpent: number}>, // 每题答题时间记录（秒）
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    // 获取应用实例，用来访问全局数据
    const app = getApp<IAppOption>();
    // 从全局数据中获取题目
    const questions = app.globalData.questions as Question[];
    
    if (questions && questions.length > 0) {
      const currentTime = Date.now();
      this.setData({
        questions: questions,
        currentQuestion: questions[0],
        totalQuestions: questions.length,
        examStartTime: currentTime, // 记录考试开始时间
        currentQuestionStartTime: currentTime // 记录第一题开始时间
      });
      
      console.log('考试开始时间:', new Date(currentTime).toLocaleString());
    } else {
      // 如果没有题目数据，提示用户
      wx.showModal({
        title: '提示',
        content: '题目数据还没有加载完成，请稍后再试',
        showCancel: false,
        success: () => {
          wx.navigateBack();
        }
      });
    }
  },

  /**
   * 用户选择答案
   * @param {any} e - 事件对象，包含用户选择的选项
   */
  selectOption(e: any) {
    const selectedOption = e.currentTarget.dataset.option;
    this.setData({
      selectedOption: selectedOption
    });
  },

  /**
   * 提交当前题目的答案或进入下一题
   */
  submitAnswer() {
    const { selectedOption, currentQuestion, score, currentIndex, answerHistory, totalQuestions, quickMode, autoNextDelay, showDetailedFeedback, currentQuestionStartTime, questionTimeRecords } = this.data;
    
    if (!selectedOption) {
      wx.showToast({
        title: '请先选择一个答案',
        icon: 'none',
        duration: 2000
      });
      return;
    }

    // 计算当前题目的答题时间
    const currentTime = Date.now();
    const timeSpentOnCurrentQuestion = Math.round((currentTime - currentQuestionStartTime) / 1000); // 秒
    
    // 记录题目答题时间
    const newTimeRecords = [...questionTimeRecords, {
      questionId: currentQuestion.id,
      timeSpent: timeSpentOnCurrentQuestion
    }];

    // 判断答案是否正确
    const isCorrect = selectedOption === currentQuestion.answer;
    let newScore = score;
    
    // 计分逻辑：答对+1，答错扣1分但不低于0
    if (isCorrect) {
      newScore += 1;
    } else {
      // 答错扣1分，但分数不会低于0
      newScore = Math.max(0, newScore - 1);
    }

    // 记录答题历史
    const newHistory = [...answerHistory, {
      questionId: currentQuestion.id,
      userAnswer: selectedOption,
      correctAnswer: currentQuestion.answer,
      isCorrect: isCorrect
    }];

    // 更新数据
    this.setData({
      score: newScore,
      showResult: true,
      isCorrect: isCorrect,
      answerHistory: newHistory,
      questionTimeRecords: newTimeRecords
    });

    console.log(`题目${currentQuestion.id}答题时间: ${timeSpentOnCurrentQuestion}秒`);

    // 判断是否为最后一题
    if (currentIndex >= totalQuestions - 1) {
      // 最后一题，显示结果后完成考试
      if (quickMode) {
        // 快速模式：显示简短提示后自动完成考试
        wx.showToast({
          title: isCorrect ? '✅ 回答正确!' : '❌ 回答错误',
          icon: 'none',
          duration: 1000
        });
        
        setTimeout(() => {
          this.finishExam();
        }, 1200);
      } else {
        // 传统模式：显示详细弹窗
        wx.showModal({
          title: isCorrect ? '回答正确！' : '回答错误！',
          content: `正确答案是：${currentQuestion.answer}. ${currentQuestion.options[currentQuestion.answer as keyof typeof currentQuestion.options]}\n\n当前得分：${newScore}\n\n考试已完成！`,
          showCancel: false,
          confirmText: '查看结果',
          success: () => {
      this.finishExam();
          }
        });
      }
    } else {
      // 不是最后一题
      if (quickMode) {
        // 快速模式：显示简短反馈后自动进入下一题
        const correctAnswerText = currentQuestion.options[currentQuestion.answer as keyof typeof currentQuestion.options];
        
        if (showDetailedFeedback) {
          // 显示详细反馈（但不需要点击确认）
          wx.showToast({
            title: isCorrect 
              ? `✅ 正确! 得分: ${newScore}` 
              : `❌ 错误! 答案: ${currentQuestion.answer}`,
            icon: 'none',
            duration: autoNextDelay - 200 // 提示持续时间比自动跳转时间稍短
          });
        } else {
          // 只显示简单的对错提示
          wx.showToast({
            title: isCorrect ? '✅ 正确!' : '❌ 错误',
            icon: 'none',
            duration: 800
          });
        }
        
        // 自动进入下一题
        setTimeout(() => {
          this.nextQuestion();
        }, autoNextDelay);
        
      } else {
        // 传统模式：显示详细弹窗，需要用户点击确认
      wx.showModal({
        title: isCorrect ? '回答正确！' : '回答错误！',
        content: `正确答案是：${currentQuestion.answer}. ${currentQuestion.options[currentQuestion.answer as keyof typeof currentQuestion.options]}\n\n当前得分：${newScore}`,
        showCancel: false,
        confirmText: '下一题',
        success: () => {
          this.nextQuestion();
        }
      });
      }
    }
  },

  /**
   * 返回上一题
   */
  previousQuestion() {
    const { currentIndex, questions } = this.data;
    
    if (currentIndex > 0) {
      const prevIndex = currentIndex - 1;
      const currentTime = Date.now();
      
      this.setData({
        currentIndex: prevIndex,
        currentQuestion: questions[prevIndex],
        selectedOption: '', // 清空选择
        showResult: false,
        currentQuestionStartTime: currentTime // 记录返回题目的开始时间
      });
      
      console.log(`返回第${prevIndex + 1}题，时间:`, new Date(currentTime).toLocaleString());
    }
  },

  /**
   * 进入下一题
   */
  nextQuestion() {
    const { currentIndex, questions, totalQuestions } = this.data;
    
    if (currentIndex < totalQuestions - 1) {
      // 还有下一题
      const nextIndex = currentIndex + 1;
      const currentTime = Date.now();
      
      this.setData({
        currentIndex: nextIndex,
        currentQuestion: questions[nextIndex],
        selectedOption: '', // 清空选择
        showResult: false,
        currentQuestionStartTime: currentTime // 记录新题目的开始时间
      });
      
      console.log(`开始第${nextIndex + 1}题，时间:`, new Date(currentTime).toLocaleString());
    } else {
      // 已完成所有题目，跳转到结果页面
      this.finishExam();
    }
  },

  /**
   * 完成考试，跳转到结果页面
   */
  finishExam() {
    // 使用更新后的数据（因为在调用finishExam前已经更新了分数和答题历史）
    setTimeout(() => {
      const { score, totalQuestions, answerHistory, examStartTime, questionTimeRecords } = this.data;
      
      // 计算统计数据
      const correctCount = answerHistory.filter(item => item.isCorrect).length;
      const wrongCount = totalQuestions - correctCount;
      const accuracy = ((correctCount / totalQuestions) * 100).toFixed(1);
      
      // 计算考试总耗时
      const examEndTime = Date.now();
      const totalTimeSpent = Math.round((examEndTime - examStartTime) / 1000); // 总时间（秒）
      
      console.log('考试结束时间:', new Date(examEndTime).toLocaleString());
      console.log('考试总耗时:', totalTimeSpent, '秒');
      console.log('每题答题时间记录:', questionTimeRecords);
      
      // 将考试结果存储到页面栈中，传递给结果页面
      const resultData = {
        score: score,
        totalQuestions: totalQuestions,
        correctCount: correctCount,
        wrongCount: wrongCount,
        accuracy: accuracy,
        answerHistory: answerHistory,
        questions: this.data.questions,
        
        // 时间数据
        examStartTime: examStartTime,
        examEndTime: examEndTime,
        totalTimeSpent: totalTimeSpent,
        questionTimeRecords: questionTimeRecords
      };

      // 先将结果数据存储到全局，确保数据在页面跳转前就准备好
      const app = getApp<IAppOption>();
      (app as any).examResult = resultData;

      // 然后跳转到结果页面
      wx.navigateTo({
        url: '/pages/text_view/text_view',
        success: () => {
          console.log('考试完成，成功跳转到结果页面');
        },
        fail: (error) => {
          console.error('跳转到结果页面失败:', error);
          wx.showToast({
            title: '页面跳转失败，请重试',
            icon: 'none',
            duration: 2000
          });
        }
      });
    }, 100); // 小延迟确保数据已更新
  },

  /**
   * 返回上一页
   */
  goBack() {
    wx.navigateBack();
  },

  /**
   * 切换答题模式
   */
  toggleQuickMode(e: any) {
    const isQuickMode = e.detail.value;
    this.setData({
      quickMode: isQuickMode
    });
    
    wx.showToast({
      title: isQuickMode ? '已切换到快速模式' : '已切换到传统模式',
      icon: 'none',
      duration: 1500
    });
  },

  /**
   * 设置自动跳转延迟时间
   * @param {number} delay 延迟时间（毫秒）
   */
  setAutoNextDelay(delay: number) {
    this.setData({
      autoNextDelay: Math.max(500, Math.min(3000, delay)) // 限制在500ms-3000ms之间
    });
  },

  /**
   * 切换详细反馈显示
   */
  toggleDetailedFeedback() {
    this.setData({
      showDetailedFeedback: !this.data.showDetailedFeedback
    });
    
    wx.showToast({
      title: this.data.showDetailedFeedback ? '已开启详细反馈' : '已关闭详细反馈',
      icon: 'none',
      duration: 1500
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})